﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class StockProductoEnPresupuesto
    {
        public string Grupo
        {
            get
            {
                return ElementoAsociado.Grupo.Trim();
            }
        }
        public string SubGrupo
        {
            get
            {
                return ElementoAsociado.SubGrupo.Trim();
            }
        }
        public string ElementoNombre
        {
            get
            {
                return ElementoAsociado.Item.Trim();
            }
        }
        public bool ProductoEnDeposito
        {
            get
            {
                return MovimientoAsociado.ProductoEstaEnDeposito;
            }
        }
        /// <summary>
        /// Devuelve si o no
        /// </summary>
        public string ProductoEnDepositoString
        {
            get
            {
                if (MovimientoAsociado.ProductoEstaEnDeposito == true)
                    return "Si";
                else
                    return "No";
            }
        }
        public string PrecioVentaString
        {
            get
            {
                return PrecioVenta.ToString(Parametros.FormatoDinero);
            }
        }
        public decimal PrecioUnitario
        {
            get
            {
                if ((Cantidad <= 0)
                    || (PrecioVenta <= decimal.Zero))
                    return PrecioVenta;

                return PrecioVenta / Cantidad;
            }
        }

        public string PrecioUnitarioString
        {
            get
            {
                return PrecioUnitario.ToString(Parametros.FormatoDinero);
            }
        }

        public string ProductoUbicacion
        {
            get
            {
                return ProductoAsociado.Ubicacion;
            }
        }
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class StockProductoEnPresupuesto
    {
        #region Atributos
        protected int _id;
        protected int _IdElemento;
        protected int _IdMovimientoDeStock;
        protected int _Cantidad;
        protected decimal _PrecioCosto;
        protected decimal _PrecioVenta;
        protected bool _ProductoProvistoPorElTaller;
        protected int _IdProducto;
        protected string _ProductoNombre;
        protected string _Responsable;
        

        //Objetos asociados
        protected StockMovimientoStock _MovimientoAsociado;
        protected StockProducto _ProductoAsociado;
        protected ONElemento _ElementoAsociado;
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public int IdElemento
        {
            get
            {
                return _IdElemento;
            }
            set
            {
                _IdElemento = value;
            }
        }
        public int IdMovimientoDeStock
        {
            get
            {
                return _IdMovimientoDeStock;
            }
            set
            {
                _IdMovimientoDeStock = value;
            }
        }
        public int Cantidad
        {
            get
            {
                return _Cantidad;
            }
            set
            {
                _Cantidad = value;
            }
        }
        public decimal PrecioCosto
        {
            get
            {
                return _PrecioCosto;
            }
            set
            {
                _PrecioCosto = value;
            }
        }
        public decimal PrecioVenta
        {
            get
            {
                return _PrecioVenta;
            }
            set
            {
                _PrecioVenta = value;
            }
        }
        public bool ProductoProvistoPorElTaller
        {
            get
            {
                return _ProductoProvistoPorElTaller;
            }
            set
            {
                _ProductoProvistoPorElTaller = value;
            }
        }
        public int IdProducto
        {
            get
            {
                return _IdProducto;
            }
            set
            {
                _IdProducto = value;
            }
        }
        public string ProductoNombre
        {
            get
            {
                return _ProductoNombre;
            }
            set
            {
                _ProductoNombre = value;
            }
        }
        public string Responsable
        {
            get
            {
                return _Responsable;
            }
            set
            {
                _Responsable = value;
            }
        }
        
        //Objetos asociados
        public StockMovimientoStock MovimientoAsociado
        {
            get
            {
                if ((_MovimientoAsociado == null)
                    && (IdMovimientoDeStock > 0))
                    _MovimientoAsociado = StockMovimientoStock.CrearStockMovimientoStock(IdMovimientoDeStock);

                return _MovimientoAsociado;
            }
            set
            {
                _MovimientoAsociado = value;

                if (value == null)
                    IdMovimientoDeStock = -1;
                else
                    IdMovimientoDeStock = value.ID;
            }
        }
        public StockProducto ProductoAsociado
        {
            get
            {
                if ((_ProductoAsociado == null)
                    && (IdProducto > 0))
                    _ProductoAsociado = StockProducto.CrearStockProducto(IdProducto);

                return _ProductoAsociado;
            }
            set
            {
                _ProductoAsociado = value;

                if (value == null)
                    IdProducto = -1;
                else
                    IdProducto = value.ID;
            }
        }
        public ONElemento ElementoAsociado
        {
            get
            {
                if ((_ElementoAsociado == null)
                    && (_IdElemento > 0))
                    _ElementoAsociado = ONElemento.CrearElemento(_IdElemento);

                return _ElementoAsociado;
            }
            set
            {
                _ElementoAsociado = value;

                if (value == null)
                    _IdElemento = -1;
                else
                    _IdElemento = value.ID;
            }
        }

        //Propiedades derivadas
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static StockProductoEnPresupuestoTableAdapter _StockProductoEnPresupuestoAD;
        protected static StockProductoEnPresupuestoTableAdapter Adaptador
        {
            get
            {
                if (_StockProductoEnPresupuestoAD == null)
                    _StockProductoEnPresupuestoAD = new StockProductoEnPresupuestoTableAdapter();

                return _StockProductoEnPresupuestoAD;
            }
        }
        protected static StockProductoEnPresupuesto ObtenerPorID(int pID)
        {
            _STG_DAL.StockProductoEnPresupuestoDataTable _dt;

            _dt = Adaptador.ObtenerPorID(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.StockProductoEnPresupuestoRow)_dt.Rows[0]);

            return null;
        }
        protected static StockProductoEnPresupuesto AsignarRowAObjeto(_STG_DAL.StockProductoEnPresupuestoRow pRow)
        {
            StockProductoEnPresupuesto _StockProductoEnPresupuesto = new StockProductoEnPresupuesto();
            if (pRow != null)
            {
                _StockProductoEnPresupuesto = new StockProductoEnPresupuesto();
                _StockProductoEnPresupuesto.ID = pRow.ID;
                _StockProductoEnPresupuesto.IdElemento = pRow.IdElemento;
                _StockProductoEnPresupuesto.IdMovimientoDeStock = pRow.IdMovimientoDeStock;
                _StockProductoEnPresupuesto.Cantidad = pRow.Cantidad;
                _StockProductoEnPresupuesto.PrecioCosto = pRow.PrecioCosto;
                _StockProductoEnPresupuesto.PrecioVenta = pRow.PrecioVenta;
                _StockProductoEnPresupuesto.ProductoProvistoPorElTaller = pRow.ProductoProvistoPorElTaller;
                _StockProductoEnPresupuesto.IdProducto = pRow.IdProducto;
                _StockProductoEnPresupuesto.ProductoNombre = pRow.ProductoNombre;
                _StockProductoEnPresupuesto.Responsable = pRow.Responsable;
            }
            return _StockProductoEnPresupuesto;
        }
        protected StockProductoEnPresupuesto Insertar(int pIdElemento,int pIdMovimientoDeStock,int pCantidad,decimal pPrecioCosto,decimal pPrecioVenta,bool pProductoProvistoPorElTaller)
        {
            ID = int.Parse(Adaptador.Insertar(pIdElemento, pIdMovimientoDeStock, pCantidad, pPrecioCosto, pPrecioVenta, pProductoProvistoPorElTaller).ToString());
            return this;
        }
        //protected bool Actualizar(string pRazonSocial, string pCUIT, string pDireccion, string pObservaciones, string pTelefono, bool pEstaActivo, int pID)
        //{
        //    if (0 < Adaptador.Actualizar(pRazonSocial, pCUIT, pDireccion, pObservaciones, pTelefono, pEstaActivo, pID))
        //        return true;
        //    else
        //        return false;
        //}
        /// <summary>
        /// Elimina el producto en presupuesto y genera el movimiento de stock inverso.
        /// </summary>
        /// <param name="pResponsable"></param>
        public void Eliminar(string pResponsable)
        {
            //Antes de eliminar, tengo que generar un movimiento de stock inverso que indique el que se devuelve el stock
            StockMovimientoStock.GenerarMovimientoDeStockConDiferencia("Reposición de stock por eliminar producto de presupuesto numero " + this.IdElemento.ToString(), pResponsable, Cantidad * -1, IdProducto, true);

            Adaptador.Eliminar(this.ID);
            
        }
        /// <summary>
        /// Elimina el productoEnPresupuesto y no hace nada mas
        /// </summary>
        /// <param name="pIdProductoEnPresupuesto"></param>
        public static void Eliminar(int pIdProductoEnPresupuesto)
        {
            Adaptador.Eliminar(pIdProductoEnPresupuesto);
        }
        protected static StockProductoEnPresupuestoColeccion AsignarStockProductoEnPresupuestoTableAdapterAStockProductoEnPresupuestoColeccion(_STG_DAL.StockProductoEnPresupuestoDataTable pDataTable)
        {
            StockProductoEnPresupuestoColeccion _StockProductoEnPresupuestoes = new StockProductoEnPresupuestoColeccion();
            StockProductoEnPresupuesto _StockProductoEnPresupuesto;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.StockProductoEnPresupuestoRow _row in pDataTable.Rows)
                {
                    _StockProductoEnPresupuesto = AsignarRowAObjeto(_row);
                    if (_StockProductoEnPresupuesto != null)
                        _StockProductoEnPresupuestoes.Add(_StockProductoEnPresupuesto);
                }
            }
            return _StockProductoEnPresupuestoes;
        }
        public static StockProductoEnPresupuestoColeccion ObtenerProductosDePresupuesto(int pIdPresupuesto)
        {
            return AsignarStockProductoEnPresupuestoTableAdapterAStockProductoEnPresupuestoColeccion(Adaptador.ObtenerProductosDePresupuesto(pIdPresupuesto));
        }
        public static StockProductoEnPresupuesto ObtenerPorIdMovimientoDeStock(int pIdMovimientoDeStock)
        {
            _STG_DAL.StockProductoEnPresupuestoDataTable _dt;

            _dt = Adaptador.ObtenerPorIdMovimientoDeStock(pIdMovimientoDeStock);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.StockProductoEnPresupuestoRow)_dt.Rows[0]);

            return null;
        }
        #endregion

        #region Métodos
        public StockProductoEnPresupuesto()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            IdElemento = -1;
            IdMovimientoDeStock = -1;
            Cantidad = 0;
            PrecioCosto = decimal.Zero;
            PrecioVenta = decimal.Zero;
            ProductoProvistoPorElTaller = true;
            IdProducto = -1;
            ProductoNombre = "";
            Responsable = "";
        }

        public static StockProductoEnPresupuesto CrearStockProductoEnPresupuesto()
        {
            StockProductoEnPresupuesto _StockProductoEnPresupuesto = new StockProductoEnPresupuesto();
            return _StockProductoEnPresupuesto;
        }
        public static StockProductoEnPresupuesto CrearStockProductoEnPresupuesto(int pID)
        {
            StockProductoEnPresupuesto _StockProductoEnPresupuesto = ObtenerPorID(pID);
            return _StockProductoEnPresupuesto;
        }
        //public void Actualizar()
        //{
            
        //}
        public StockProductoEnPresupuesto Insertar()
        {
            return Insertar(IdElemento, IdMovimientoDeStock, Cantidad, PrecioCosto, PrecioVenta, ProductoProvistoPorElTaller);
        }
        #endregion

        #region Metodos para datasource

        //public void Actualizar(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        //{
        //    if (pStockProductoEnPresupuesto != null)
        //        pStockProductoEnPresupuesto.Actualizar();
        //}
        public StockProductoEnPresupuesto Insertar(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        {
            if (pStockProductoEnPresupuesto != null)
                return pStockProductoEnPresupuesto.Insertar();
            return null;
        }
        public void Eliminar(StockProductoEnPresupuesto pStockProductoEnPresupuesto, string pResponsable)
        {
            pStockProductoEnPresupuesto.Eliminar(pResponsable);
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class StockProductoEnPresupuestoColeccion : System.Collections.CollectionBase
    {
        public void Add(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        {
            this.List.Add(pStockProductoEnPresupuesto);
        }
        public void AddUnico(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        {
            foreach (StockProductoEnPresupuesto _StockProductoEnPresupuesto in this)
                if (pStockProductoEnPresupuesto.ID == _StockProductoEnPresupuesto.ID)
                    return;
            this.List.Add(pStockProductoEnPresupuesto);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pStockProductoEnPresupuesto.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public StockProductoEnPresupuesto this[int index]
        {
            get { return ((StockProductoEnPresupuesto)(this.List[index])); }
            set { this.List[index] = value; }
        }

        #region Metodos de colección

        #endregion
        #region Para datasource
        public void Insertar(StockProductoEnPresupuesto pStockProductoEnPresupuesto)
        {
            pStockProductoEnPresupuesto.Insertar(pStockProductoEnPresupuesto);
        }
        #endregion
    }
}


